# 据说这是一道动态规划题
# 子问题定义，dp[i]为前i个字符所能构成的松散子序列的最大价值
# 也就是说，主要讨论的是在第i个元素一定取的情况下，前dp[0:i-1] => [0->i-2](切片的语法)个元素怎么取，
# 右开区间的原因是有[松散: P(i) - P(i-1) >= 2]子序列的要求
# [松散: P(i) - P(i-1) >= 2] -> [松散: P(i-1) <= P(i) - 2] 当P(i)确定的时候，P(i-1)可以选的范围是在间隔分别为0，1，2的地方
# 所以:
# i=0 dp[0] = value(s[0])
# i=1 dp[1] = value(s[1])
# i=2 dp[2] = value(s[2]) + value(s[0])  由于松散序列的距离要求
# i=3 dp[3] = value(s[3]) + max(dp[i-2], dp[i-3])

def get_value(char):
    return ord(char)-96


def solution1():
    # print(get_value('a'))  # 测试值的获取是否成功
    s = input()
    length = len(s)
    dp = [0] * length
    # 初始化dp
    dp[0] = get_value(s[0])
    if length != 1:
        dp[1] = get_value(s[1])  # 这一部分要考虑字符串可能长度为1
        # 填充dp数组
        for i in range(2, length):
            dp[i] = get_value(s[i]) + max(dp[i - 2], dp[i - 3])
        res = max(dp[-1], dp[-2])
    else:
        res = dp[0]
    print(res)


def solution2():
    # timeout 75%
    # 优化点一优化后 100%
    # print(get_value('a'))  # 测试值的获取是否成功
    s = input()
    length = len(s)
    dp = [0] * length
    # 初始化dp
    dp[0] = get_value(s[0])
    res = 0
    if length != 1:
        dp[1] = get_value(s[1])  # 这一部分要考虑字符串可能长度为1
        # 填充dp数组
        for i in range(2, length):
            # dp[i] = get_value(s[i]) + max(dp[0:i-1])  # 耗时可优化
            dp[i] = get_value(s[i]) + max(dp[i-2], dp[i-3])  # 优化点1
            # 为什么可以这样优化？
            # 假设还可以考虑dp[i-4]
            # 此时有 dp[i-4] dp[i-3] dp[i-2] (dp[i-1] 不满足松散距离条件) dp[i]
            # 显然，dp[i-4] 肯定小于dp[i-2]的价值，至少差一个value(i-2)，因为为了价值的最大化，对于dp[i]来说，
            # 如果在这些中选的是dp[i-4]的话，显然value(i-2)也满足松散距离的要求，可以直接纳入，
            # 所以说，为了满足最大化价值的需求，选取的子序列的元素在原串上的最大间隔元素数只能为2，也就是差3
        res = max(dp)  # 耗时可优化
    else:
        res = dp[0]
    print(res)


if __name__ == '__main__':
    solution1()
    # solution2()